#include <iostream>
#include <cstring>
#include <stdexcept>

template <typename T>
class my_vector {  // 自定义vector容器，空间连续，自动调节大小
private:
    T* data;         // 存储元素的动态数组
    size_t m_size;     // 当前元素个数（无符号整数）
    size_t m_capacity; // 当前容量

    // 扩容函数：容量翻倍
    void resize() {
        size_t new_capacity = (m_capacity == 0) ? 1 : (m_capacity * 2);
        T* new_data = new T[new_capacity];
        for (size_t i = 0; i < m_size; ++i) {
            new_data[i] = data[i];
        }

        // 释放旧内存
        delete[] data;
        data = new_data;
        m_capacity = new_capacity;
    }

public:
    // 可修改迭代器
    class iterator {
    private:
        T* m_pointer;
        friend class my_vector<T>;  // 允许my_vector访问私有成员

    public:
        iterator(T* ptr = nullptr) : m_pointer(ptr) {}

        // 解引用运算符
        T& operator*() {
            if (m_pointer == nullptr) {
                throw std::runtime_error("Dereferencing null iterator");
            }
            return *m_pointer;
        }

        T* operator->() {
            if (m_pointer == nullptr) {
                throw std::runtime_error("Dereferencing null iterator");
            }
            return m_pointer;
        }

        // 前缀自增
        iterator& operator++() {
            if (m_pointer != nullptr) {
                ++m_pointer;
            }
            return *this;
        }

        // 前缀自减
        iterator& operator--() {
            if (m_pointer != nullptr) {
                --m_pointer;
            }
            return *this;
        }

        // 后缀自增
        iterator operator++(int) {
            iterator temp = *this;  // 保存当前状态
            ++(*this);              // 调用前缀自增
            return temp;
        }

        // 后缀自减
        iterator operator--(int) {
            iterator temp = *this;
            --(*this);
            return temp;
        }

        // 比较相等
        bool operator==(const iterator& other) const { 
            return m_pointer == other.m_pointer;
        }

        // 比较不等
        bool operator!=(const iterator& other) const {  
            return m_pointer != other.m_pointer;
        }

        // 迭代器加整数
        iterator operator+(int i) const { 
            return iterator(m_pointer + i);
        }

        // 迭代器减整数
        iterator operator-(int i) const { 
            return iterator(m_pointer - i);
        }

        // 迭代器+=
        iterator& operator+=(int n){
            m_pointer+=n;
            return *this;
        }

        // 迭代器-=
        iterator& operator-=(int n){
            m_pointer-=n;
            return *this;
        }

        size_t operator-(const iterator& other) const
        {
            if(m_pointer-other.m_pointer<0)
            {
                throw std::out_of_range("<0,no meaning");
            }
            return m_pointer-other.m_pointer;
        }

    };

    // 迭代器接口
    iterator begin() {
        return iterator(data);  // 指向第一个元素
    }

    iterator end() {
        return iterator(data + m_size);  // 指向最后一个元素的下一个位置
    }

    iterator insert(const iterator& pos,const T& num)
    {
        if (m_size >= m_capacity) {
            resize();
        }
        //找到插入位置
        size_t index = pos-begin();

        for(size_t i = m_size;i > index;i--) data[i] = data[i-1];
        data[index] = num;
        ++m_size;

        return iterator(data+index);//返回指针
    }

    iterator erase(const iterator& pos)
    {
        if(empty())
        {
            throw std::out_of_range("vector is empty");
        }
        //找到删除位置
        size_t index = pos-begin();
        if(index < 0)  throw std::out_of_range("Invalid iterator position");
        for(size_t i = index;i < m_size-1;i++){
            data[i] = data[i+1];
        }  
        --m_size;
        return iterator(data+index);

    }

    // 判断容器是否为空
    bool empty() const { 
        return m_size == 0;
    }

    // 尾插元素
    void push_back(const T& value) {
        if (m_size >= m_capacity) {
            resize();
        }
        data[m_size++] = value;
    }

    // 尾删元素
    void pop_back() {
        if (empty()) {
            throw std::out_of_range("my_vector is empty");
        }
        --m_size; 
    }

    // 下标访问运算符
    T& operator[](size_t index) {
        if (index >= m_size) {
            throw std::out_of_range("Index out of range");
        }
        return data[index];
    }
    size_t size()
    {
        return m_size;
    }
    size_t capacity()
    {
        return m_capacity;
    }


    // 默认构造函数
    my_vector() : data(nullptr), m_size(0), m_capacity(0) {} 

    // 带初始容量的构造函数（explicit禁止隐式转换）
    explicit my_vector(size_t cap) {
        if (cap == 0) {  // 若容量为0，按默认构造处理
            data = nullptr;
            m_size = 0;
            m_capacity = 0;
        } else {
            m_capacity = cap;
            data = new T[m_capacity];
            m_size = 0;  // 初始元素个数为0
        }
    }

    // 析构函数：释放动态内存
    ~my_vector() {
        delete[] data;
        data = nullptr;
        m_size = 0;
        m_capacity = 0;
    }
};